/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 言初
 * Date: 2023-12-25
 * Time: 22:16
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;




class Test {
    //7-8 寻找第K小（分治版）
    // 数组中第k小的元素的最终位置应为数组的k-1下标位置处的值。
    //所要求的时间复杂度是：O(N)


    public static int d=0; //存放最终结果


    public static void  func(int[] arr,int left, int right,int k){
        //使用单趟快排的思想进行求解
        //找到一个基准值，然后设置2个坐标点，一个从左向右走，一个从右向左走，直到相遇为止，然后把基准值和相遇位置进行元素值的交换
        // 最后得到的结果是基准值的左边都是比基准值小的数，基准值的右边都是比基准值大的数了
        if(left>right){
            return ;
        }
        if(left==right){
            if(left == k - 1) {
                d = arr[left];
            }
            return ;
        }


        //单趟快排的实现，我觉得也应该使用三数取中的优化操作，来提高代码的效率
        int ret=funcmid(arr,left,right);
        //交换ret下标和left下标的值
        if(ret!=left){
            int tmp=arr[ret];
            arr[ret]=arr[left];
            arr[left]=tmp;
        }



        //记录一下基准值的值和下标
        int num=arr[left];
        int i=left;

        //单趟快排
        int l=left;
        int r=right;
        while(l<r){
            //右边找小，左边找大，  右边先走
            while(r>l){
                if(arr[r]<num){
                    break;
                }else{
                    r--;
                }
            }

            while(l<r){
                if(arr[l]>num){
                    break;
                }else{
                    l++;
                }
            }

            //交换l和r的值
            if(l!=r){
                int p=arr[l];
                arr[l]=arr[r];
                arr[r]=p;
            }
        }

        //l==r
        // 交换l 和基准值的位置
        //交换以后，基准值就到达了它的最终位置了
        if(l!=i){
            int swap=arr[l];
            arr[l]=arr[i];
            arr[i]=swap;
        }


        //此时l的值和k-1进行比较
        if(l<k-1){
            //递归右边
            func(arr,l+1,right,k);
        }else if(l==k-1){
            //递归结束
            d=arr[l];
            return;
        }else if(l>k-1){
            //递归左边
            func(arr,left,l-1,k);
        }
    }


    // 三数取中的优化
    public static int funcmid(int[] arr,int left,int right){
        //返回三个数中中等大小的下标值
        int a=arr[left];
        int b=arr[(left+right)/2];
        int c=arr[right];
        int ret=0;

        if(a>=b){
            if(a<c){
                ret = left;
                return ret;
            }else if(b>c){
                ret = (left+right)/2;
                return ret;
            }else{
                ret = right;
                return ret;
            }
        }

        if(a<b){
            if(b<c){
                ret = (left+right)/2;
                return ret;
            }else if(a>c){
                ret = left;
                return ret;
            }else{
                ret = right;
                return ret;
            }
        }

        return ret;
    }

}




public class Main9 {

    // 7-9 铺设油井管道plus
    //横纵坐标先用int吧，距离用double
    //水平方向有一条主管道（应该是一个整数吧）
    // 主管道所在的y的位置是平分所有子管道的位置



    public static long func(int[] arr,Test test){

        int n=arr.length;

        //升序
        test.func(arr,0,n-1,n/2 +1 );

        int y=test.d;

        //System.out.println(y);
        //主管道所在的y值找到了
        long num=0;
        for(int i=0;i<n;i++){
            num+=Math.abs(arr[i]-y);
        }
        return num;
    }


    public static void main(String[] args) throws IOException{
        Test test=new Test();

        StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        st.nextToken();
        int n = (int) st.nval;

        int[] arr=new int[n];

        for (int i = 0; i < n; i++) {
            st.nextToken();
            int x=(int) st.nval;
            st.nextToken();
            int y=(int) st.nval;
            arr[i]=y;
        }

        long ret=func(arr,test);

        System.out.println(ret);
    }
}












